{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:28.857302Z",
     "start_time": "2025-01-17T04:18:28.850922Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 数据准备",
   "id": "1073bc64c567ba13"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:28.967957Z",
     "start_time": "2025-01-17T04:18:28.919322Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# 训练集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 测试集\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)\n"
   ],
   "id": "55788f25672e1ebe",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.099210Z",
     "start_time": "2025-01-17T04:18:28.977960Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        # img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "_mean, _std = cal_mean_std(train_ds)\n",
    "print(_mean, _std)\n",
    "\n",
    "transforms = nn.Sequential(\n",
    "    Normalize(mean=_mean, std=_std)\n",
    ")"
   ],
   "id": "7296e2499aa5be79",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.2860]) tensor([0.3205])\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 定义模型",
   "id": "b5e4f17ae389c008"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.114870Z",
     "start_time": "2025-01-17T04:18:36.100201Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=10):\n",
    "        super().__init__()\n",
    "        self.transform = transforms  # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()  # 展平层\n",
    "        self.linear_relu_stack = nn.Sequential(  # 线性层+激活层堆叠\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        # 加layers_num-1个线性层+激活层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"linear{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu{i}\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"linear_out\", nn.Linear(100, 10))\n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        print(\"初始化权重\")\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)  # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias)  # 全零初始化偏置项\n",
    "        print(\"权重初始化完成\")\n",
    "\n",
    "    def forward(self, x):  # 前向传播\n",
    "        x = self.transform(x)  # 预处理,标准化\n",
    "        # 将输入数据 x 展平（Flatten），通常用于将多维数据转换为一维数据。\n",
    "        x = self.flatten(x)\n",
    "        # logits 是模型的原始输出，通常是未经过 Softmax 或 Sigmoid 处理的分数。\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算模型参数数量\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")  #np.prod是计算张量的元素个数\n",
    "    total += np.prod(value.shape) \n",
    "total"
   ],
   "id": "d3016623476b4fd4",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n",
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tparamerters num: 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "271410"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练模型",
   "id": "8fb5dfcd77513c03"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.232909Z",
     "start_time": "2025-01-17T04:18:36.115867Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluate(model, data_loader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in data_loader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 前向传播\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 预测\n",
    "        preds = logits.argmax(axis=-1)  # 预测类别\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())  # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)  # 计算准确率\n",
    "    return np.mean(loss_list), acc  # # 返回验证集平均损失和准确率\n"
   ],
   "id": "24550945260b9755",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Save Best Model",
   "id": "6fd06a23a5bccc23"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.239464Z",
     "start_time": "2025-01-17T04:18:36.233906Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        self.save_dir = save_dir  # 保存路径\n",
    "        self.save_step = save_step  # 保存步数\n",
    "        self.save_best_only = save_best_only  # 是否只保存最好的模型\n",
    "        self.best_metric = -1  # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        # 创建保存路径\n",
    "        if not os.path.exists(self.save_dir):  # 如果不存在保存路径，则创建\n",
    "            os.makedirs(self.save_dir)\n",
    "\n",
    "    # 对象被调用时：当你将对象像函数一样调用时，Python 会自动调用 __call__ 方法。\n",
    "    # state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "    # metric 是指标，可以是验证集的准确率，也可以是其他指标\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return  # 不是保存步数，则直接返回\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None  # 必须传入metric\n",
    "            if metric >= self.best_metric:  # 如果当前指标大于最好的指标\n",
    "                # save checkpoint\n",
    "                # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"04_best.ckpt\"))\n",
    "                self.best_metric = metric  # 更新最好的指标\n",
    "        else:\n",
    "            # 保存模型\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "            # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n"
   ],
   "id": "e93aec97aec45c4e",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Early Stopping",
   "id": "3f9a004729448217"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.246710Z",
     "start_time": "2025-01-17T04:18:36.241469Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        self.patience = patience  # 多少个step没有提升就停止训练\n",
    "        self.min_delta = min_delta  # 最小的提升幅度\n",
    "        self.best_metric = -1  # 记录的最好的指标\n",
    "        self.counter = 0  # 计数器，记录连续多少个step没有提升\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果指标提升了\n",
    "            self.best_metric = metric  # 更新最好的指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加一\n",
    "\n",
    "    @property  # 使用@property装饰器，使得 对象.early_stop可以调用，不需要()\n",
    "    def early_stop(self):\n",
    "        # 如果计数器大于等于patience，则返回True，停止训练\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "d8fdc303a4d27c00",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练",
   "id": "b56dab87e8ff6485"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.256402Z",
     "start_time": "2025-01-17T04:18:36.247713Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def training(model,\n",
    "             train_loader,\n",
    "             test_loader,\n",
    "             epoch,\n",
    "             loss_fct,\n",
    "             optimizer,\n",
    "             tensorboard_callback=None,\n",
    "             save_ckpt_callback=None,\n",
    "             early_stop_callback=None,\n",
    "             eval_step=500,\n",
    "             ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0  # 全局步数\n",
    "    model.train()  # 训练模式\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 前向传播\n",
    "                logits = model(datas)\n",
    "                loss = loss_fct(logits, labels)  # 训练集损失\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "\n",
    "                # 反向传播\n",
    "                optimizer.zero_grad()  # 梯度清零\n",
    "                loss.backward()  # 反向传播\n",
    "                optimizer.step()  # 优化器更新参数\n",
    "\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 评估\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 评估模式\n",
    "                    # 验证集损失和准确率\n",
    "                    val_loss, val_acc = evaluate(model, test_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    model.train()  # 训练模式\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # model.state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), val_acc)\n",
    "                        # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 early stopping\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        early_stop_callback(val_acc)\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 早停，返回记录字典 record_dict\n",
    "\n",
    "                # 更新进度条和全局步数\n",
    "                pbar.update(1)  # 更新进度条\n",
    "                global_step += 1  # 全局步数加一\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict  # 训练结束，返回记录字典 record_dict\n"
   ],
   "id": "2602ccd3cb633f69",
   "outputs": [],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "d111e077fd6e015"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:18:36.266642Z",
     "start_time": "2025-01-17T04:18:36.258407Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork()\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 2. 定义优化器 采用SGD优化器\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 3.save model checkpoint\n",
    "save_ckpt_callback = SaveCheckpointsCallback(save_dir=\"checkpoints\", save_step=500, save_best_only=True)\n",
    "\n",
    "# 4. early stopping\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.01)"
   ],
   "id": "8b42caff09582576",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:24:24.955515Z",
     "start_time": "2025-01-17T04:18:36.267646Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = model.to(device)  # 将模型移到GPU上\n",
    "\n",
    "# 训练过程\n",
    "record_dict = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    test_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "1b4d7f1cfe612c71",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "b72c14792440436c865bd8592c3d5156"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 15 / global_step 56250\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:24:25.209546Z",
     "start_time": "2025-01-17T04:24:24.956517Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def plot_record_curves(record_dict, sample_step=1000):\n",
    "    # .set_index(\"step\") 将 step 列设置为 DataFrame 的索引\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    last_step = train_df.index[-1]  # 最后一步的步数\n",
    "\n",
    "    print(train_df)\n",
    "    print(val_df)\n",
    "\n",
    "    # 画图 \n",
    "    fig_num = len(train_df.columns)  # 画两张图,分别是损失和准确率\n",
    "\n",
    "    # plt.subplots：用于创建一个包含多个子图的图形窗口。\n",
    "    # 1：表示子图的行数为 1。\n",
    "    # fig_num：表示子图的列数，即子图的数量。\n",
    "    # figsize=(5 * fig_num, 5)：设置整个图形窗口的大小，宽度为 5 * fig_num，高度为 5。\n",
    "    # fig：返回的图形对象（Figure），用于操作整个图形窗口。\n",
    "    # axs：返回的子图对象（Axes 或 Axes 数组），用于操作每个子图。\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index 是 x 轴数据（通常是 step）。\n",
    "        # train_df[item] 是 y 轴数据（当前指标的值）。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=\"train:\" + item)\n",
    "        # val_df.index 是 x 轴数据。\n",
    "        # val_df[item] 是 y 轴数据。\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=\"val:\" + item)\n",
    "        axs[idx].grid()  # 显示网格\n",
    "        axs[idx].legend()  # 显示图例\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))  # 设置x轴刻度\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{x // 1000}k\", range(0, last_step + 1, 5000)))  # 设置x轴标签\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_record_curves(record_dict)"
   ],
   "id": "de28437c6058f608",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           loss     acc\n",
      "step                   \n",
      "0      2.287305  0.0625\n",
      "1000   0.637498  0.5625\n",
      "2000   0.396972  0.8125\n",
      "3000   0.930343  0.7500\n",
      "4000   0.469468  0.8125\n",
      "5000   0.217153  0.9375\n",
      "6000   0.361563  0.8125\n",
      "7000   0.178760  1.0000\n",
      "8000   0.221029  0.9375\n",
      "9000   0.517494  0.7500\n",
      "10000  0.156870  0.9375\n",
      "11000  0.226394  1.0000\n",
      "12000  0.425683  0.8750\n",
      "13000  0.470127  0.8125\n",
      "14000  0.198481  0.9375\n",
      "15000  0.389094  0.8750\n",
      "16000  0.209812  0.9375\n",
      "17000  0.135503  0.9375\n",
      "18000  0.068150  1.0000\n",
      "19000  0.299714  0.8750\n",
      "20000  0.347798  0.8125\n",
      "21000  0.506447  0.8125\n",
      "22000  0.444535  0.8125\n",
      "23000  0.701042  0.8750\n",
      "24000  0.173569  0.9375\n",
      "25000  0.138436  0.9375\n",
      "26000  0.274115  0.9375\n",
      "27000  0.153371  1.0000\n",
      "28000  0.543238  0.6875\n",
      "29000  0.196880  0.9375\n",
      "30000  0.272738  0.8125\n",
      "31000  0.163763  0.9375\n",
      "32000  0.129778  1.0000\n",
      "33000  0.710649  0.6250\n",
      "34000  0.327946  0.8125\n",
      "35000  0.219227  0.9375\n",
      "36000  0.145118  1.0000\n",
      "37000  0.186974  0.8750\n",
      "38000  0.165921  0.9375\n",
      "39000  0.178262  0.9375\n",
      "40000  0.426745  0.8750\n",
      "41000  0.193072  0.9375\n",
      "42000  0.184042  0.9375\n",
      "43000  0.083405  0.9375\n",
      "44000  0.071037  1.0000\n",
      "45000  0.292039  0.9375\n",
      "46000  0.245200  0.9375\n",
      "47000  0.424454  0.9375\n",
      "48000  0.045926  0.9375\n",
      "49000  0.021996  1.0000\n",
      "50000  0.070239  1.0000\n",
      "51000  0.185212  0.8750\n",
      "52000  0.189581  0.9375\n",
      "53000  0.090475  0.9375\n",
      "54000  0.255078  0.9375\n",
      "55000  0.264103  0.9375\n",
      "56000  0.402662  0.8125\n",
      "           loss     acc\n",
      "step                   \n",
      "0      2.308162  0.0545\n",
      "3750   0.456742  0.8377\n",
      "7500   0.412745  0.8511\n",
      "11250  0.388237  0.8609\n",
      "15000  0.380633  0.8643\n",
      "18750  0.357610  0.8744\n",
      "22500  0.365616  0.8734\n",
      "26250  0.358739  0.8722\n",
      "30000  0.352455  0.8729\n",
      "33750  0.352542  0.8767\n",
      "37500  0.340252  0.8821\n",
      "41250  0.338071  0.8815\n",
      "45000  0.353383  0.8782\n",
      "48750  0.346471  0.8831\n",
      "52500  0.365089  0.8771\n",
      "56250  0.374197  0.8730\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:24:25.216103Z",
     "start_time": "2025-01-17T04:24:25.211551Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"train\"][-5:]",
   "id": "775b113bb78383fa",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.4963409900665283, 'acc': 0.75, 'step': 56246},\n",
       " {'loss': 0.08777099847793579, 'acc': 1.0, 'step': 56247},\n",
       " {'loss': 0.13158822059631348, 'acc': 0.9375, 'step': 56248},\n",
       " {'loss': 0.2611559331417084, 'acc': 0.875, 'step': 56249},\n",
       " {'loss': 0.19056233763694763, 'acc': 0.875, 'step': 56250}]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:24:25.222304Z",
     "start_time": "2025-01-17T04:24:25.217106Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"val\"][-10:]",
   "id": "dbb21c010aaef95e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.36561628266572954, 'acc': 0.8734, 'step': 22500},\n",
       " {'loss': 0.3587386570930481, 'acc': 0.8722, 'step': 26250},\n",
       " {'loss': 0.3524551813215017, 'acc': 0.8729, 'step': 30000},\n",
       " {'loss': 0.3525424619525671, 'acc': 0.8767, 'step': 33750},\n",
       " {'loss': 0.340251984539628, 'acc': 0.8821, 'step': 37500},\n",
       " {'loss': 0.3380714510694146, 'acc': 0.8815, 'step': 41250},\n",
       " {'loss': 0.3533829983651638, 'acc': 0.8782, 'step': 45000},\n",
       " {'loss': 0.34647094862014055, 'acc': 0.8831, 'step': 48750},\n",
       " {'loss': 0.36508892250582575, 'acc': 0.8771, 'step': 52500},\n",
       " {'loss': 0.37419685057103635, 'acc': 0.873, 'step': 56250}]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 评估以及上线",
   "id": "1fa2f200745f7b63"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:24:25.230466Z",
     "start_time": "2025-01-17T04:24:25.223309Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = NeuralNetwork()  #上线时加载模型\n",
    "model = model.to(device)  # 将模型移到GPU上"
   ],
   "id": "b106406c03208c15",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:26:18.701941Z",
     "start_time": "2025-01-17T04:26:17.509249Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 加载最好的模型\n",
    "# torch.load：加载保存的模型权重或整个模型。\n",
    "# \"checkpoints/best.ckpt\"：模型权重文件路径。\n",
    "# weights_only=True：仅加载模型的权重，而不是整个模型（包括结构和参数）。这是 PyTorch 2.1 引入的新特性，用于增强安全性。\n",
    "# map_location=device：将模型加载到当前设备（GPU或CPU）。\n",
    "model.load_state_dict(torch.load(\"checkpoints/04_best.ckpt\", weights_only=True, map_location=device))  # 加载最好的模型\n",
    "\n",
    "model.eval()  # 评估模式\n",
    "loss, acc = evaluate(model, test_loader, loss_fct)\n",
    "print(f\"Test loss: {loss:.4f}, Test acc: {acc:.4f}\")"
   ],
   "id": "26cdacda63d5388e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.3403, Test acc: 0.8821\n"
     ]
    }
   ],
   "execution_count": 20
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
